package com.liam.translation.xunfei;

import cn.xfyun.api.TransClient;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 翻译服务
 * 封装讯飞翻译API调用
 * 
 * @author liam
 */
public class TranslationService {

    private static final Logger logger = LoggerFactory.getLogger(TranslationService.class);

    // 讯飞翻译API鉴权参数
    private static final String appId = "98e7934f";
    private static final String apiKey = "17352bf789ecaa4e9483ff7a60ee76e2";
    private static final String apiSecret = "ZDkxNDAwMmNjNjNhZTc1OWZiNDFiYzkz";

    // 语言代码
    public static final String LANG_CHINESE = "cn";
    public static final String LANG_ENGLISH = "en";

    // 翻译客户端
    private final TransClient client;

    // 单例实例
    private static TranslationService instance;

    /**
     * 获取翻译服务实例（单例模式）
     * 
     * @return 翻译服务实例
     */
    public static synchronized TranslationService getInstance() {
        if (instance == null) {
            instance = new TranslationService();
        }
        return instance;
    }

    /**
     * 构造函数，初始化翻译客户端
     */
    private TranslationService() {
        this.client = new TransClient.Builder(appId, apiKey, apiSecret).build();
        logger.info("翻译服务已初始化");
    }

    /**
     * 通用翻译方法，支持中英互译
     * 
     * @param text     要翻译的文本
     * @param fromLang 源语言代码（cn或en）
     * @param toLang   目标语言代码（cn或en）
     * @return 翻译后的文本
     */
    public String translate(String text, String fromLang, String toLang) {
        if (text == null || text.trim().isEmpty()) {
            return "";
        }

        try {
            // 调用小牛翻译API
            String response = client.sendNiuTrans(text);
            logger.debug("翻译响应: {}", response);

            // 解析翻译结果
            JSONObject jsonResponse = JSON.parseObject(response);
            if (jsonResponse.containsKey("data") && jsonResponse.getJSONObject("data").containsKey("result")) {
                String rawTranslatedText = jsonResponse.getJSONObject("data").getString("result");

                // 尝试从结果中提取实际的翻译文本
                String cleanTranslatedText = extractTranslationText(rawTranslatedText);
                logger.info("翻译成功 ({} -> {}): {} -> {}", fromLang, toLang, text, cleanTranslatedText);
                return cleanTranslatedText;
            } else {
                logger.warn("翻译响应格式异常: {}", response);
                return "翻译失败: 响应格式异常";
            }
        } catch (Exception e) {
            logger.error("翻译异常", e);
            return "翻译失败: " + e.getMessage();
        }
    }

    /**
     * 将中文翻译为英文
     * 
     * @param text 要翻译的中文文本
     * @return 翻译后的英文文本
     */
    public String translateToEnglish(String text) {
        return translateWithIst(text, LANG_CHINESE, LANG_ENGLISH);
    }

    /**
     * 将英文翻译为中文
     * 
     * @param text 要翻译的英文文本
     * @return 翻译后的中文文本
     */
    public String translateToChineseFromEnglish(String text) {
        return translateWithIst(text, LANG_ENGLISH, LANG_CHINESE);
    }

    /**
     * 使用自研机器翻译API翻译文本
     * 
     * @param text     要翻译的文本
     * @param fromLang 源语言代码
     * @param toLang   目标语言代码
     * @return 翻译后的文本
     */
    public String translateWithIst(String text, String fromLang, String toLang) {
        if (text == null || text.trim().isEmpty()) {
            return "";
        }

        try {
            // 调用自研机器翻译API
            String response = client.sendIst(text);
            logger.debug("IST翻译响应: {}", response);

            // 解析翻译结果
            JSONObject jsonResponse = JSON.parseObject(response);
            if (jsonResponse.containsKey("data") && jsonResponse.getJSONObject("data").containsKey("result")) {
                String rawTranslatedText = jsonResponse.getJSONObject("data").getString("result");

                // 尝试从结果中提取实际的翻译文本
                String cleanTranslatedText = extractTranslationText(rawTranslatedText);
                logger.info("IST翻译成功 ({} -> {}): {} -> {}", fromLang, toLang, text, cleanTranslatedText);
                return cleanTranslatedText;
            } else {
                logger.warn("IST翻译响应格式异常: {}", response);
                return "翻译失败: 响应格式异常";
            }
        } catch (Exception e) {
            logger.error("IST翻译异常", e);
            return "翻译失败: " + e.getMessage();
        }
    }

    /**
     * 从翻译结果中提取实际的翻译文本
     * 
     * @param rawTranslation 原始翻译结果（可能是JSON格式）
     * @return 提取后的纯文本翻译结果
     */
    private String extractTranslationText(String rawTranslation) {
        try {
            // 检查是否是JSON格式
            if (rawTranslation.startsWith("{") && rawTranslation.endsWith("}")) {
                JSONObject jsonResult = JSON.parseObject(rawTranslation);

                // 尝试提取常见的翻译结果格式
                if (jsonResult.containsKey("trans_result")
                        && jsonResult.getJSONObject("trans_result").containsKey("dst")) {
                    return jsonResult.getJSONObject("trans_result").getString("dst");
                }

                // 其他可能的格式
                if (jsonResult.containsKey("result")) {
                    return jsonResult.getString("result");
                }

                if (jsonResult.containsKey("dst")) {
                    return jsonResult.getString("dst");
                }

                // 如果无法识别格式，记录警告并返回原始文本
                logger.warn("无法从JSON中提取翻译文本: {}", rawTranslation);
            }

            // 如果不是JSON或无法解析，直接返回原始文本
            return rawTranslation;
        } catch (Exception e) {
            logger.warn("提取翻译文本时出错: {}", e.getMessage());
            return rawTranslation;
        }
    }
}